Termination w.r.t. Q of the following Term Rewriting System could not be shown:

Q restricted rewrite system:
The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.


QTRS
  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

QUOTE1(sel2(X, Y)) -> SEL12(X, Y)
DBL11(s1(X)) -> DBL11(X)
QUOTE1(s1(X)) -> QUOTE1(X)
INDX2(cons2(X, Y), Z) -> SEL2(X, Z)
QUOTE1(dbl1(X)) -> DBL11(X)
DBLS1(cons2(X, Y)) -> DBL1(X)
SEL2(s1(X), cons2(Y, Z)) -> SEL2(X, Z)
DBLS1(cons2(X, Y)) -> DBLS1(Y)
SEL12(s1(X), cons2(Y, Z)) -> SEL12(X, Z)
DBL1(s1(X)) -> DBL1(X)
FROM1(X) -> FROM1(s1(X))
INDX2(cons2(X, Y), Z) -> INDX2(Y, Z)

The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS
  ↳ DependencyPairsProof
QDP
      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(sel2(X, Y)) -> SEL12(X, Y)
DBL11(s1(X)) -> DBL11(X)
QUOTE1(s1(X)) -> QUOTE1(X)
INDX2(cons2(X, Y), Z) -> SEL2(X, Z)
QUOTE1(dbl1(X)) -> DBL11(X)
DBLS1(cons2(X, Y)) -> DBL1(X)
SEL2(s1(X), cons2(Y, Z)) -> SEL2(X, Z)
DBLS1(cons2(X, Y)) -> DBLS1(Y)
SEL12(s1(X), cons2(Y, Z)) -> SEL12(X, Z)
DBL1(s1(X)) -> DBL1(X)
FROM1(X) -> FROM1(s1(X))
INDX2(cons2(X, Y), Z) -> INDX2(Y, Z)

The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 8 SCCs with 4 less nodes.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
QDP
            ↳ QDPOrderProof
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SEL12(s1(X), cons2(Y, Z)) -> SEL12(X, Z)

The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be strictly oriented and are deleted.


SEL12(s1(X), cons2(Y, Z)) -> SEL12(X, Z)
The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
SEL12(x1, x2)  =  x1
s1(x1)  =  s1(x1)
cons2(x1, x2)  =  x1

Lexicographic Path Order [19].
Precedence:
trivial


The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
            ↳ QDPOrderProof
QDP
                ↳ PisEmptyProof
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
QDP
            ↳ QDPOrderProof
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

DBL11(s1(X)) -> DBL11(X)

The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be strictly oriented and are deleted.


DBL11(s1(X)) -> DBL11(X)
The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
DBL11(x1)  =  DBL11(x1)
s1(x1)  =  s1(x1)

Lexicographic Path Order [19].
Precedence:
s1 > DBL11


The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
QDP
                ↳ PisEmptyProof
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
QDP
            ↳ QDPOrderProof
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(s1(X)) -> QUOTE1(X)

The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be strictly oriented and are deleted.


QUOTE1(s1(X)) -> QUOTE1(X)
The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
QUOTE1(x1)  =  QUOTE1(x1)
s1(x1)  =  s1(x1)

Lexicographic Path Order [19].
Precedence:
s1 > QUOTE1


The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
QDP
                ↳ PisEmptyProof
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FROM1(X) -> FROM1(s1(X))

The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
QDP
            ↳ QDPOrderProof
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SEL2(s1(X), cons2(Y, Z)) -> SEL2(X, Z)

The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be strictly oriented and are deleted.


SEL2(s1(X), cons2(Y, Z)) -> SEL2(X, Z)
The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
SEL2(x1, x2)  =  x1
s1(x1)  =  s1(x1)
cons2(x1, x2)  =  x1

Lexicographic Path Order [19].
Precedence:
trivial


The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
QDP
                ↳ PisEmptyProof
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
QDP
            ↳ QDPOrderProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

INDX2(cons2(X, Y), Z) -> INDX2(Y, Z)

The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be strictly oriented and are deleted.


INDX2(cons2(X, Y), Z) -> INDX2(Y, Z)
The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
INDX2(x1, x2)  =  INDX1(x1)
cons2(x1, x2)  =  cons1(x2)

Lexicographic Path Order [19].
Precedence:
[INDX1, cons1]


The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
QDP
                ↳ PisEmptyProof
          ↳ QDP
          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
QDP
            ↳ QDPOrderProof
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

DBL1(s1(X)) -> DBL1(X)

The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be strictly oriented and are deleted.


DBL1(s1(X)) -> DBL1(X)
The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
DBL1(x1)  =  DBL1(x1)
s1(x1)  =  s1(x1)

Lexicographic Path Order [19].
Precedence:
s1 > DBL1


The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
QDP
                ↳ PisEmptyProof
          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
QDP
            ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

DBLS1(cons2(X, Y)) -> DBLS1(Y)

The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be strictly oriented and are deleted.


DBLS1(cons2(X, Y)) -> DBLS1(Y)
The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
DBLS1(x1)  =  DBLS1(x1)
cons2(x1, x2)  =  cons2(x1, x2)

Lexicographic Path Order [19].
Precedence:
cons2 > DBLS1


The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
QDP
                ↳ PisEmptyProof

Q DP problem:
P is empty.
The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.